home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 97 / CD-ROM 97 / CD-ROM 97.iso / internet / ghostzilla / ghsetup.exe / chrome / comm.jar / content / communicator / pref / pref-fonts.js < prev    next >
Encoding:
Text File  |  2002-05-18  |  24.4 KB  |  640 lines
  1. /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Netscape Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/NPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is 
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *    Gervase Markham <gerv@gerv.net>
  24.  *    Tuukka Tolvanen <tt@lament.cjb.net>
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the NPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the NPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. try
  41.   {
  42.     var fontList = Components.classes["@mozilla.org/gfx/fontlist;1"].createInstance();
  43.     if (fontList)
  44.       fontList = fontList.QueryInterface(Components.interfaces.nsIFontList);
  45.  
  46.     var pref = Components.classes["@mozilla.org/preferences;1"].getService( Components.interfaces.nsIPref );
  47.   }
  48. catch(e)
  49.   {
  50.     dump("failed to get font list or pref object: "+e+" in pref-fonts.js\n");
  51.   }
  52.  
  53. var fontTypes   = ["serif", "sans-serif", "cursive", "fantasy", "monospace"];
  54. var variableSize, fixedSize, minSize, languageList;
  55. var languageData = [];
  56. var currentLanguage;
  57. var gPrefutilitiesBundle;
  58.  
  59. // manual data retrieval function for PrefWindow
  60. function GetFields()
  61.   {
  62.     var dataObject = parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"];
  63.  
  64.     // store data for language independent widgets
  65.     var lists = ["selectLangs", "proportionalFont"];
  66.     for( var i = 0; i < lists.length; i++ )
  67.       {
  68.         if( !dataObject.dataEls )
  69.           dataObject.dataEls = [];
  70.         dataObject.dataEls[ lists[i] ] = [];
  71.         dataObject.dataEls[ lists[i] ].value = document.getElementById( lists[i] ).value;
  72.       }
  73.  
  74.    dataObject.defaultFont = document.getElementById( "proportionalFont" ).value;
  75.    dataObject.fontDPI = document.getElementById( "screenResolution" ).value;
  76.    dataObject.useDocFonts = document.getElementById( "browserUseDocumentFonts" ).checked ? 1 : 0;
  77.  
  78.     // save current state for language dependent fields and store
  79.     saveState();
  80.     dataObject.languageData = languageData;
  81.  
  82.     return dataObject;
  83.   }
  84.  
  85. // manual data setting function for PrefWindow
  86. function SetFields( aDataObject )
  87.   {
  88.     languageData = aDataObject.languageData ? aDataObject.languageData : languageData ;
  89.     currentLanguage = aDataObject.currentLanguage ? aDataObject.currentLanguage : null ;
  90.  
  91.     var lists = ["selectLangs", "proportionalFont"];
  92.     var prefvalue;
  93.     
  94.     for( var i = 0; i < lists.length; i++ )
  95.       {
  96.         var element = document.getElementById( lists[i] );
  97.         if( aDataObject.dataEls )
  98.           {
  99.             element.selectedItem = element.getElementsByAttribute( "value", aDataObject.dataEls[ lists[i] ].value )[0];
  100.           }
  101.         else
  102.           {
  103.             var prefstring = element.getAttribute( "prefstring" );
  104.             var preftype = element.getAttribute( "preftype" );
  105.             if( prefstring && preftype )
  106.               {
  107.                 var prefvalue = parent.hPrefWindow.getPref( preftype, prefstring );
  108.                 element.selectedItem = element.getElementsByAttribute( "value", prefvalue )[0];
  109.               }
  110.           }
  111.       }
  112.  
  113.     var screenResolution = document.getElementById( "screenResolution" );
  114.     var resolution;
  115.     
  116.     if( aDataObject.fontDPI )
  117.       {
  118.         resolution = aDataObject.fontDPI;
  119.       }
  120.     else
  121.       {
  122.         prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.screen_resolution" );
  123.         if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  124.             resolution = prefvalue;
  125.         else
  126.             resolution = 96; // If it all goes horribly wrong, fall back on 96.
  127.       }
  128.     
  129.     setResolution( resolution );
  130.     
  131.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.screen_resolution" ) ) {
  132.         screenResolution.disabled = true;
  133.     }
  134.  
  135.     var useDocFontsCheckbox = document.getElementById( "browserUseDocumentFonts" );
  136.     if( aDataObject.useDocFonts != undefined )
  137.       useDocFontsCheckbox.checked = aDataObject.useDocFonts ? true : false;
  138.     else
  139.       {
  140.         prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.use_document_fonts" );
  141.         if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  142.           useDocFontsCheckbox.checked = prefvalue ? true : false ;
  143.       }
  144.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.use_document_fonts" ) ) {
  145.         useDocFontsCheckbox.disabled = true;
  146.     }
  147.   }
  148.  
  149. function Startup()
  150.   {
  151.     variableSize = document.getElementById( "sizeVar" );
  152.     fixedSize    = document.getElementById( "sizeMono" );
  153.     minSize      = document.getElementById( "minSize" );
  154.     languageList = document.getElementById( "selectLangs" );
  155.  
  156.     gPrefutilitiesBundle = document.getElementById("bundle_prefutilities");
  157.  
  158.     // register our ok callback function
  159.     parent.hPrefWindow.registerOKCallbackFunc( saveFontPrefs );
  160.  
  161.     // eventually we should detect the default language and select it by default
  162.     selectLanguage();
  163.     
  164.     // Allow user to ask the OS for a DPI if we are under X
  165.     if ((navigator.appVersion.indexOf("X11") != -1) || (navigator.appVersion.indexOf("OS/2") != -1))
  166.       {
  167.          document.getElementById( "systemResolution" ).removeAttribute( "hidden" ); 
  168.       }
  169.     
  170.     // Set up the labels for the standard issue resolutions
  171.     var resolution;
  172.     resolution = document.getElementById( "screenResolution" );
  173.  
  174.     // Set an attribute on the selected resolution item so we can fall back on
  175.     // it if an invalid selection is made (select "Other...", hit Cancel)
  176.     resolution.selectedItem.setAttribute("current", "true");
  177.  
  178.     var defaultResolution;
  179.     var otherResolution;
  180.  
  181.     // On OS/2, 120 is the default system resolution.
  182.     // 96 is valid, but used only for for 640x480.
  183.     if (navigator.appVersion.indexOf("OS/2") != -1)
  184.       {
  185.         defaultResolution = "120";
  186.         otherResolution = "96";
  187.       } else {
  188.         defaultResolution = "96";
  189.         otherResolution = "72";
  190.       }
  191.  
  192.     var dpi = resolution.getAttribute( "dpi" );
  193.     resolution = document.getElementById( "defaultResolution" );
  194.     resolution.setAttribute( "value", defaultResolution );
  195.     resolution.setAttribute( "label", dpi.replace(/\$val/, defaultResolution ) );
  196.     resolution = document.getElementById( "otherResolution" );
  197.     resolution.setAttribute( "value", otherResolution );
  198.     resolution.setAttribute( "label", dpi.replace(/\$val/, otherResolution ) );
  199.  
  200.     // Get the pref and set up the dialog appropriately. Startup is called
  201.     // after SetFields so we can't rely on that call to do the business.
  202.     prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.screen_resolution" );
  203.     if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  204.         resolution = prefvalue;
  205.     else
  206.         resolution = 96; // If it all goes horribly wrong, fall back on 96.
  207.     
  208.     setResolution( resolution );
  209.  
  210.     // This prefstring is a contrived pref whose sole purpose is to lock some
  211.     // elements in this panel.  The value of the pref is not used and does not matter.
  212.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.languageList" ) ) {
  213.       disableAllFontElements();
  214.     }
  215.   }
  216.  
  217. function listElement( aListID )
  218.   {
  219.     this.listElement = document.getElementById( aListID );
  220.   }
  221.  
  222. listElement.prototype =
  223.   {
  224.     clearList:
  225.       function ()
  226.         {
  227.           // remove the menupopup node child of the menulist.
  228.           this.listElement.removeChild( this.listElement.firstChild );
  229.         },
  230.  
  231.     appendString:
  232.       function ( aString )
  233.         {
  234.           var menuItemNode = document.createElement( "menuitem" );
  235.           if( menuItemNode )
  236.             {
  237.               menuItemNode.setAttribute( "label", aString );
  238.               this.listElement.firstChild.appendChild( menuItemNode );
  239.             }
  240.         },
  241.  
  242.     appendFontNames: 
  243.       function ( aDataObject ) 
  244.         { 
  245.           var popupNode = document.createElement( "menupopup" ); 
  246.           var strDefaultFontFace = "";
  247.           var fontName;
  248.           while (aDataObject.hasMoreElements()) {
  249.             fontName = aDataObject.getNext();
  250.             fontName = fontName.QueryInterface(Components.interfaces.nsISupportsWString);
  251.             var fontNameStr = fontName.toString();
  252.             if (strDefaultFontFace == "")
  253.               strDefaultFontFace = fontNameStr;
  254.             var itemNode = document.createElement( "menuitem" );
  255.             itemNode.setAttribute( "value", fontNameStr );
  256.             itemNode.setAttribute( "label", fontNameStr );
  257.             popupNode.appendChild( itemNode );
  258.           }
  259.           if (strDefaultFontFace != "") {
  260.             this.listElement.removeAttribute( "disabled" );
  261.           } else {
  262.             this.listElement.setAttribute( "value", strDefaultFontFace );
  263.             this.listElement.setAttribute( "label",
  264.                                     gPrefutilitiesBundle.getString("nofontsforlang") );
  265.             this.listElement.setAttribute( "disabled", "true" );
  266.           }
  267.           this.listElement.appendChild( popupNode ); 
  268.           return strDefaultFontFace;
  269.         } 
  270.   };
  271.  
  272. function saveFontPrefs()
  273.   {
  274.     // if saveState function is available, assume can call it.
  275.     // why is this extra qualification required?!!!!
  276.     if( top.hPrefWindow.wsm.contentArea.saveState )
  277.       {
  278.         saveState();
  279.         parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"] = GetFields();
  280.       }
  281.  
  282.     // saving font prefs
  283.     var dataObject = parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"];
  284.     var pref = parent.hPrefWindow.pref;
  285.     for( var language in dataObject.languageData )
  286.       {
  287.         for( var type in dataObject.languageData[language].types )
  288.           {
  289.             var fontPrefString = "font.name." + type + "." + language;
  290.             var currValue = "";
  291.             try
  292.               {
  293.                 currValue = pref.CopyUnicharPref( fontPrefString );
  294.               }
  295.             catch(e)
  296.               {
  297.               }
  298.             if( currValue != dataObject.languageData[language].types[type] )
  299.               pref.SetUnicharPref( fontPrefString, dataObject.languageData[language].types[type] );
  300.           }
  301.         var variableSizePref = "font.size.variable." + language;
  302.         var fixedSizePref = "font.size.fixed." + language;
  303.         var minSizePref = "font.minimum-size." + language;
  304.         var currVariableSize = 12, currFixedSize = 12, minSizeVal = 0;
  305.         try
  306.           {
  307.             currVariableSize = pref.GetIntPref( variableSizePref );
  308.             currFixedSize = pref.GetIntPref( fixedSizePref );
  309.             minSizeVal = pref.GetIntPref( minSizePref );
  310.           }
  311.         catch(e)
  312.           {
  313.           }
  314.         if( currVariableSize != dataObject.languageData[language].variableSize )
  315.           pref.SetIntPref( variableSizePref, dataObject.languageData[language].variableSize );
  316.         if( currFixedSize != dataObject.languageData[language].fixedSize )
  317.           pref.SetIntPref( fixedSizePref, dataObject.languageData[language].fixedSize );
  318.         if ( minSizeVal != dataObject.languageData[language].minSize ) {
  319.           pref.SetIntPref ( minSizePref, dataObject.languageData[language].minSize );
  320.         }
  321.       }
  322.  
  323.     // font scaling
  324.     var fontDPI       = parseInt( dataObject.fontDPI );
  325.     var documentFonts = dataObject.useDocFonts;
  326.     var defaultFont   = dataObject.defaultFont;
  327.  
  328.     try
  329.       {
  330.         var currDPI = pref.GetIntPref( "browser.display.screen_resolution" );
  331.         var currFonts = pref.GetIntPref( "browser.display.use_document_fonts" );
  332.         var currDefault = pref.CopyUnicharPref( "font.default" );
  333.       }
  334.     catch(e)
  335.       {
  336.       }
  337.     if( currDPI != fontDPI )
  338.       pref.SetIntPref( "browser.display.screen_resolution", fontDPI );
  339.     if( currFonts != documentFonts )
  340.       pref.SetIntPref( "browser.display.use_document_fonts", documentFonts );
  341.     if( currDefault != defaultFont )
  342.       {
  343.         pref.SetUnicharPref( "font.default", defaultFont );
  344.       }
  345.   }
  346.  
  347. function saveState()
  348.   {
  349.     for( var i = 0; i < fontTypes.length; i++ )
  350.       {
  351.         // preliminary initialisation
  352.         if( currentLanguage && !languageData[currentLanguage] )
  353.           languageData[currentLanguage] = [];
  354.         if( currentLanguage && !languageData[currentLanguage].types )
  355.           languageData[currentLanguage].types = [];
  356.         // save data for the previous language
  357.         if( currentLanguage && languageData[currentLanguage] &&
  358.             languageData[currentLanguage].types )
  359.           languageData[currentLanguage].types[fontTypes[i]] = document.getElementById( fontTypes[i] ).value;
  360.       }
  361.  
  362.     if( currentLanguage && languageData[currentLanguage] &&
  363.         languageData[currentLanguage].types )
  364.       {
  365.         languageData[currentLanguage].variableSize = parseInt( variableSize.value );
  366.         languageData[currentLanguage].fixedSize = parseInt( fixedSize.value );
  367.         languageData[currentLanguage].minSize = parseInt( minSize.value );
  368.       }
  369.   }
  370.  
  371. // Selects size (or the nearest entry that exists in the list)
  372. // in the menulist minSize
  373. function minSizeSelect(size)
  374.   {
  375.     var items = minSize.getElementsByAttribute( "value", size );
  376.     if (items.length > 0)
  377.       minSize.selectedItem = items[0];
  378.     else if (size < 6)
  379.       minSizeSelect(6);
  380.     else if (size > 24)
  381.       minSizeSelect(24);
  382.     else
  383.       minSizeSelect(size - 1);
  384.   }
  385.  
  386. function selectLanguage()
  387.   {
  388.     // save current state
  389.     saveState();
  390.  
  391.     if( !currentLanguage )
  392.       currentLanguage = languageList.value;
  393.  
  394.     for( var i = 0; i < fontTypes.length; i++ )
  395.       {
  396.         // build and populate the font list for the newly chosen font type
  397.         var fontEnumerator = fontList.availableFonts(languageList.value, fontTypes[i]);
  398.         var selectElement = new listElement( fontTypes[i] );
  399.         selectElement.clearList();
  400.         var strDefaultFontFace = selectElement.appendFontNames(fontEnumerator);
  401.         //the first font face name returned by the enumerator is our last resort
  402.         var defaultListSelection = selectElement.listElement.getElementsByAttribute( "value", strDefaultFontFace)[0];
  403.  
  404.         //fall-back initialization values (first font face list entry)
  405.         var defaultListSelection = strDefaultFontFace ? selectElement.listElement.getElementsByAttribute( "value", strDefaultFontFace)[0] : null;
  406.  
  407.         if( languageData[languageList.value] )
  408.           {
  409.             // data exists for this language, pre-select items based on this information
  410.             var dataElements = selectElement.listElement.getElementsByAttribute( "value", languageData[languageList.value].types[fontTypes[i]] );
  411.             var selectedItem = dataElements.length ? dataElements[0] : defaultListSelection;
  412.  
  413.             minSizeSelect(languageData[languageList.value].minSize);
  414.             if (strDefaultFontFace)
  415.               {
  416.                 selectElement.listElement.selectedItem = selectedItem;
  417.                 variableSize.removeAttribute("disabled");
  418.                 fixedSize.removeAttribute("disabled");
  419.                 minSize.removeAttribute("disabled");
  420.                 variableSize.selectedItem = variableSize.getElementsByAttribute( "value", languageData[languageList.value].variableSize )[0];
  421.                 fixedSize.selectedItem = fixedSize.getElementsByAttribute( "value", languageData[languageList.value].fixedSize )[0];
  422.               }
  423.             else
  424.               {
  425.                 variableSize.setAttribute("disabled","true");
  426.                 fixedSize.setAttribute("disabled","true");
  427.                 minSize.setAttribute("disabled","true");
  428.               }
  429.           }
  430.         else
  431.           {
  432.  
  433.             if (strDefaultFontFace) {
  434.                 //initialze pref panel only if font faces are available for this language family
  435.  
  436.                 var selectVal;
  437.                 var selectedItem;
  438.  
  439.                 try {
  440.                     var fontPrefString = "font.name." + fontTypes[i] + "." + languageList.value;
  441.                     selectVal   = parent.hPrefWindow.pref.CopyUnicharPref( fontPrefString );
  442.                     var dataEls = selectElement.listElement.getElementsByAttribute( "value", selectVal );
  443.  
  444.                     // we need to honor name-list in case name is unavailable 
  445.                     if (!dataEls.length) {
  446.                         var fontListPrefString = "font.name-list." + fontTypes[i] + "." + languageList.value;
  447.                         var nameList   = parent.hPrefWindow.pref.CopyUnicharPref( fontListPrefString );
  448.                         var fontNames = nameList.split(",");
  449.                         var stripWhitespace = /^\s*(.*)\s*$/;
  450.  
  451.                         for (j = 0; j < fontNames.length; j++) {
  452.                           selectVal = fontNames[j].replace(stripWhitespace, "$1");
  453.                           dataEls = selectElement.listElement.getElementsByAttribute("value", selectVal);
  454.                           if (dataEls.length)  
  455.                             break;  // exit loop if we find one
  456.                         }
  457.                     }                     
  458.  
  459.                     selectedItem = dataEls.length ? dataEls[0] : defaultListSelection;
  460.                     if (!dataEls.length) 
  461.                       selectedVal = strDefaultFontFace;
  462.                 }
  463.                 catch(e) {
  464.                     //always initialize: fall-back to default values
  465.                     selectVal       = strDefaultFontFace;
  466.                     selectedItem    = defaultListSelection;
  467.                 }
  468.  
  469.                 selectElement.listElement.selectedItem = selectedItem;
  470.  
  471.                 variableSize.removeAttribute("disabled");
  472.                 fixedSize.removeAttribute("disabled");
  473.                 minSize.removeAttribute("disabled");
  474.  
  475.  
  476.                 try {
  477.                     var variableSizePref = "font.size.variable." + languageList.value;
  478.                     var fixedSizePref = "font.size.fixed." + languageList.value;
  479.  
  480.                     var sizeVarVal = parent.hPrefWindow.pref.GetIntPref( variableSizePref );
  481.                     var sizeFixedVal = parent.hPrefWindow.pref.GetIntPref( fixedSizePref );
  482.  
  483.                     variableSize.selectedItem = variableSize.getElementsByAttribute( "value", sizeVarVal )[0];
  484.  
  485.                     fixedSize.selectedItem = fixedSize.getElementsByAttribute( "value", sizeFixedVal )[0];
  486.                 }
  487.  
  488.                 catch(e) {
  489.                     //font size lists can simply deafult to the first entry
  490.                 }
  491.                 var minSizeVal = 0;
  492.                 try {
  493.                   var minSizePref = "font.minimum-size." + languageList.value;
  494.                   minSizeVal = pref.GetIntPref( minSizePref );
  495.                 }
  496.                 catch(e) {}
  497.                 minSizeSelect( minSizeVal );
  498.  
  499.             }
  500.             else
  501.             {
  502.                 //disable otherwise                
  503.                 variableSize.setAttribute("disabled","true");
  504.                 fixedSize.setAttribute("disabled","true");
  505.                 minSize.setAttribute("disabled","true");
  506.                 minSizeSelect(0);
  507.             }
  508.           }
  509.       }
  510.     currentLanguage = languageList.value;
  511.   }
  512.  
  513. function changeScreenResolution()
  514.   {
  515.     var screenResolution = document.getElementById("screenResolution");
  516.     var userResolution = document.getElementById("userResolution");
  517.  
  518.     var previousSelection = screenResolution.getElementsByAttribute("current", "true")[0];
  519.  
  520.     if (screenResolution.value == "other")
  521.       {
  522.         // If the user selects "Other..." we bring up the calibrate screen dialog
  523.         var rv = { newdpi : 0 };
  524.         calscreen = window.openDialog("chrome://communicator/content/pref/pref-calibrate-screen.xul", 
  525.                                       "_blank", 
  526.                                       "modal,chrome,centerscreen,resizable=no,titlebar",
  527.                                       rv);
  528.         if (rv.newdpi != -1) 
  529.           {
  530.             // They have entered values, and we have a DPI value back
  531.             var dpi = screenResolution.getAttribute( "dpi" );
  532.             setResolution ( rv.newdpi );
  533.  
  534.             previousSelection.removeAttribute("current");
  535.             screenResolution.selectedItem.setAttribute("current", "true");
  536.           }
  537.         else
  538.           {
  539.             // They've cancelled. We can't leave "Other..." selected, so...
  540.             // we re-select the previously selected item.
  541.             screenResolution.selectedItem = previousSelection;
  542.           }
  543.       }
  544.     else if (!(screenResolution.value == userResolution.value))
  545.       {
  546.         // User has selected one of the hard-coded resolutions
  547.         userResolution.setAttribute("hidden", "true");
  548.  
  549.         previousSelection.removeAttribute("current");
  550.         screenResolution.selectedItem.setAttribute("current", "true");
  551.       }
  552.   }
  553.  
  554. function setResolution( resolution )
  555.   {
  556.     // Given a number, if it's equal to a hard-coded resolution we use that,
  557.     // otherwise we set the userResolution field.
  558.     var screenResolution = document.getElementById( "screenResolution" );
  559.     var userResolution = document.getElementById( "userResolution" );
  560.  
  561.     var item = screenResolution.getElementsByAttribute( "value", resolution )[0];
  562.     if (item)
  563.       {
  564.         // If it's one of the hard-coded values, we'll select it directly 
  565.         screenResolution.selectedItem = item;
  566.         userResolution.setAttribute( "hidden", "true" );
  567.       }   
  568.     else
  569.       {
  570.         // Otherwise we need to set up the userResolution field
  571.         var dpi = screenResolution.getAttribute( "dpi" );
  572.         userResolution.setAttribute( "value", resolution );
  573.         userResolution.setAttribute( "label", dpi.replace(/\$val/, resolution) );
  574.         userResolution.removeAttribute( "hidden" );
  575.         screenResolution.selectedItem = userResolution;   
  576.       }
  577.   }
  578.   
  579. // "Calibrate screen" dialog code
  580.  
  581. function Init()
  582.   {
  583.       sizeToContent();
  584.       doSetOKCancel(onOK, onCancel);
  585.       document.getElementById("horizSize").focus();
  586.   }
  587.   
  588. function onOK()
  589.   {
  590.     // Get value from the dialog to work out dpi
  591.     var horizSize = parseFloat(document.getElementById("horizSize").value);
  592.     var units = document.getElementById("units").value;
  593.   
  594.     if (!horizSize || horizSize < 0)
  595.       {
  596.         // We can't calculate anything without a proper value
  597.         window.arguments[0].newdpi = -1;
  598.         return true;
  599.       }
  600.       
  601.     // Convert centimetres to inches.
  602.     // The magic number is allowed because it's a fundamental constant :-)
  603.     if (units === "centimetres")
  604.       {
  605.         horizSize /= 2.54;
  606.       }
  607.   
  608.     // These shouldn't change, but you can't be too careful.
  609.     var horizBarLengthPx = document.getElementById("horizRuler").boxObject.width;
  610.   
  611.     var horizDPI = parseInt(horizBarLengthPx) / horizSize;
  612.   
  613.     // Average the two <shrug>.
  614.     window.arguments[0].newdpi = Math.round(horizDPI);
  615.   
  616.     return true;
  617.   }
  618.  
  619. function onCancel()
  620.   {
  621.       // We return -1 to show that no value has been given.
  622.       window.arguments[0].newdpi = -1;
  623.       return true;
  624.   }
  625.  
  626. // disable font items, but not the browserUseDocumentFonts checkbox nor the resolution
  627. // menulist
  628. function disableAllFontElements()
  629.   {
  630.       var doc_ids = [ "selectLangs", "proportionalFont",
  631.                       "sizeVar", "serif", "sans-serif",
  632.                       "cursive", "fantasy", "monospace",
  633.                       "sizeMono", "minSize" ];
  634.       for (i=0; i<doc_ids.length; i++) {
  635.           element = document.getElementById( doc_ids[i] );
  636.           element.disabled = true;
  637.       }
  638.   }
  639.  
  640.